#region Copyright (c) 2006-2010 Widgetsphere LLC, All Rights Reserved
//--------------------------------------------------------------------- *
//                          Widgetsphere  LLC                           *
//             Copyright (c) 2006-2010 All Rights reserved              *
//                                                                      *
//                                                                      *
//This file and its contents are protected by United States and         *
//International copyright laws.  Unauthorized reproduction and/or       *
//distribution of all or any portion of the code contained herein       *
//is strictly prohibited and will result in severe civil and criminal   *
//penalties.  Any violations of this copyright will be prosecuted       *
//to the fullest extent possible under law.                             *
//                                                                      *
//THE SOURCE CODE CONTAINED HEREIN AND IN RELATED FILES IS PROVIDED     *
//TO THE REGISTERED DEVELOPER FOR THE PURPOSES OF EDUCATION AND         *
//TROUBLESHOOTING. UNDER NO CIRCUMSTANCES MAY ANY PORTION OF THE SOURCE *
//CODE BE DISTRIBUTED, DISCLOSED OR OTHERWISE MADE AVAILABLE TO ANY     *
//THIRD PARTY WITHOUT THE EXPRESS WRITTEN CONSENT OF WIDGETSPHERE LLC   *
//                                                                      *
//UNDER NO CIRCUMSTANCES MAY THE SOURCE CODE BE USED IN WHOLE OR IN     *
//PART, AS THE BASIS FOR CREATING A PRODUCT THAT PROVIDES THE SAME, OR  *
//SUBSTANTIALLY THE SAME, FUNCTIONALITY AS ANY WIDGETSPHERE PRODUCT.    *
//                                                                      *
//THE REGISTERED DEVELOPER ACKNOWLEDGES THAT THIS SOURCE CODE           *
//CONTAINS VALUABLE AND PROPRIETARY TRADE SECRETS OF WIDGETSPHERE,      *
//INC.  THE REGISTERED DEVELOPER AGREES TO EXPEND EVERY EFFORT TO       *
//INSURE ITS CONFIDENTIALITY.                                           *
//                                                                      *
//THE END USER LICENSE AGREEMENT (EULA) ACCOMPANYING THE PRODUCT        *
//PERMITS THE REGISTERED DEVELOPER TO REDISTRIBUTE THE PRODUCT IN       *
//EXECUTABLE FORM ONLY IN SUPPORT OF APPLICATIONS WRITTEN USING         *
//THE PRODUCT.  IT DOES NOT PROVIDE ANY RIGHTS REGARDING THE            *
//SOURCE CODE CONTAINED HEREIN.                                         *
//                                                                      *
//THIS COPYRIGHT NOTICE MAY NOT BE REMOVED FROM THIS FILE.              *
//--------------------------------------------------------------------- *
#endregion
using System;
using System.ComponentModel;
using System.Xml;
using System.Collections;
using Widgetsphere.Generator.Common.GeneratorFramework;
using Widgetsphere.Generator.Common.Util;
using System.Collections.Generic;

namespace Widgetsphere.Generator.Models
{
  //[
  //Editor(typeof(Widgetsphere.Generator.Design.Editors.ParameterCollectionEditor), typeof(System.Drawing.Design.UITypeEditor))
  //]
  public class ParameterCollection : BaseModelCollection, IEnumerable<Parameter>
  {
    #region Member Variables

    protected Hashtable internalList;
    protected int lastId = 1;

    #endregion

    #region Constructor

    public ParameterCollection(IModelObject root)
      : base(root)
    {
      internalList = new Hashtable();
    }

    #endregion

    #region Property Implementations

    #endregion

    #region Methods

    public Parameter[] GetById(int id)
    {
      ArrayList retval = new ArrayList();
      foreach(Parameter element in this)
      {
        if(element.Id == id)
          retval.Add(element);
      }
      return (Parameter[])retval.ToArray(typeof(Parameter));
    }

    #endregion

    #region IXMLable Members

    public override void XmlAppend(XmlNode node)
    {
      try
      {
        XmlDocument oDoc = node.OwnerDocument;

        XmlAttribute keyNode = oDoc.CreateAttribute("key");
        keyNode.Value = this.Key.ToString();
        node.Attributes.Append(keyNode);

        foreach(Parameter parameter in internalList.Values)
        {
          XmlNode parameterNode = oDoc.CreateElement("parameter");
          parameter.XmlAppend(parameterNode);
          node.AppendChild(parameterNode);
        }
      }
      catch(Exception ex)
      {
        throw;
      }

    }

    public override void XmlLoad(XmlNode node)
    {
      _key = XmlHelper.GetAttributeValue(node, "key", _key);
      XmlNodeList parameterNodes = node.SelectNodes("parameter");
      foreach(XmlNode parameterNode in parameterNodes)
      {
        Parameter newParameter = new Parameter(this.Root);
        newParameter.XmlLoad(parameterNode);
        internalList.Add(newParameter.Id, newParameter);
        if(lastId < newParameter.Id)
          lastId = newParameter.Id;
      }

      this.Dirty = false;

    }

    #endregion

    #region IEnumerable Members
    public override IEnumerator GetEnumerator()
    {
			List<Parameter> al = new List<Parameter>();
      foreach(int key in internalList.Keys)
				al.Add((Parameter)internalList[key]);
      return al.GetEnumerator();
    }
    #endregion

    #region IDictionary Members
    public bool IsReadOnly
    {
      get
      {
        return internalList.IsReadOnly;
      }
    }

    public Parameter this[int parameterId]
    {
      get
      {
        return (Parameter)internalList[parameterId];
      }
      set
      {
        internalList[parameterId] = value;
      }
    }

    public void Remove(int parameterId)
    {
      this.Root.Dirty = true;
      internalList.Remove(parameterId);
    }

    public void Remove(Parameter parameter)
    {
      this.Root.Dirty = true;
      internalList.Remove(parameter.Id);
    }

    public bool Contains(int parameterId)
    {
      return internalList.Contains(parameterId);
    }

    public override void Clear()
    {
      internalList.Clear();
    }


    private void Add(Parameter value)
    {
      internalList.Add(value.Id, value);
    }

    public Parameter Add(string name)
    {
      Parameter newItem = new Parameter(this.Root);
      newItem.Name = name;
      lastId++;
      newItem.SetId(lastId);
      this.Add(newItem);
      return newItem;
    }

    public override void AddRange(ICollection list)
    {
      foreach(Parameter element in list)
      {
        lastId++;
        element.SetId(lastId);
        internalList.Add(lastId, element);
      }
    }

    public Parameter Add()
    {
      return this.Add(this.GetUniqueName());
    }

    public bool IsFixedSize
    {
      get
      {
        return internalList.IsFixedSize;
      }
    }

    public bool Contains(string name)
    {
      foreach(Parameter parameter in this)
      {
        if(string.Compare(parameter.Name, name, true) == 0)
        {
          return true;
        }
      }
      return false;
    }

    private string GetUniqueName()
    {
			//const string baseName = "Parameter";
			//int ii = 1;
			//string newName = baseName + ii.ToString();
			//while(this.Contains(newName))
			//{
			//  ii++;
			//  newName = baseName + ii.ToString();
			//}
			//return newName;
			return "[NEW PARAMETER]";
    }

    #endregion

    #region ICollection Members

    public override bool IsSynchronized
    {
      get
      {
        return internalList.IsSynchronized;
      }
    }

    public override int Count
    {
      get
      {
        return internalList.Count;
      }
    }

    public override void CopyTo(Array array, int index)
    {
      internalList.CopyTo(array, index);
    }

    public override object SyncRoot
    {
      get
      {
        return internalList.SyncRoot;
      }
    }

    #endregion

		#region IEnumerable<Parameter> Members

		IEnumerator<Parameter> IEnumerable<Parameter>.GetEnumerator()
		{
			List<Parameter> al = new List<Parameter>();
			foreach (int key in internalList.Keys)
				al.Add((Parameter)internalList[key]);
			return al.GetEnumerator();
		}

		#endregion

  }
}
